<!DOCTYPE html>
<html class="client-nojs vector-feature-language-in-header-enabled vector-feature-language-in-main-page-header-disabled vector-feature-page-tools-pinned-disabled vector-feature-toc-pinned-clientpref-0 vector-toc-not-available vector-feature-main-menu-pinned-disabled vector-feature-limited-width-clientpref-1 vector-feature-limited-width-content-enabled vector-feature-custom-font-size-clientpref-1 vector-feature-appearance-pinned-clientpref-0 skin-theme-clientpref-day vector-sticky-header-enabled" lang="de" dir="ltr"><head>
<meta charset="UTF-8">
<title>Iterative Tiefensuche</title>
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<link rel="icon" type="image/png" href="./_res_/favicon.png">
<link rel="canonical" href="https://de.wikipedia.org/wiki/Iterative_Tiefensuche"> <link href="./_mw_/ext.math.styles.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.pygments.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.wikimediamessages.styles.css" rel="stylesheet" type="text/css">
<link href="./_mw_/skins.vector.icons.css" rel="stylesheet" type="text/css">
<link href="./_mw_/skins.vector.search.codex.styles.css" rel="stylesheet" type="text/css">
<link href="./_mw_/skins.vector.styles.css" rel="stylesheet" type="text/css">
<meta name="ResourceLoaderDynamicStyles" content="">
<link href="./_mw_/ext.gadget.citeRef.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.gadget.defaultPlainlinks.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.gadget.dewikiCommonHide.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.gadget.dewikiCommonLayout.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.gadget.dewikiCommonStyle.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.gadget.dewikiDarkmode.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.gadget.dewikiResponsive.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.gadget.specialSearch.css" rel="stylesheet" type="text/css">
<link rel="stylesheet" type="text/css" href="./_mw_/site.styles.css">
<link rel="stylesheet" type="text/css" href="./_mw_/noscript.css">
<link rel="stylesheet" type="text/css" href="./_res_/footer.css">
<link rel="stylesheet" type="text/css" href="./_res_/vector-2022.css">
</head>
<body class="skin--responsive skin-vector skin-vector-search-vue mediawiki ltr sitedir-ltr mw-hide-empty-elt ns-0 ns-subject page-Iterative_Tiefensuche rootpage-Iterative_Tiefensuche skin-vector-2022 action-view">
<div class="mw-page-container">
<div class="mw-page-container-inner">
<div class="mw-content-container">
<main id="content" class="mw-body">
<header class="mw-body-header vector-page-titlebar">
<h1 id="firstHeading" class="firstHeading mw-first-heading"><span class="mw-page-title-main">Iterative Tiefensuche</span></h1>
</header>
<a id="top"></a>
<div id="bodyContent" class="vector-body ve-init-mw-desktopArticleTarget-targetContainer" aria-labelledby="firstHeading" data-mw-ve-target-container="">
<div id="contentSub">
<div id="mw-content-subtitle"></div>
</div>
<div id="mw-content-text" class="mw-body-content mw-content-ltr" lang="de" dir="ltr"><div class="mw-content-ltr mw-parser-output" lang="de" dir="ltr"><p>Die <b>iterative Tiefensuche</b> (<span style="font-style:normal;font-weight:normal"><a href="Englische_Sprache" title="Englische Sprache">englisch</a></span> <span lang="en-Latn" style="font-style:italic"><i>iterative deepening depth-first search</i></span>, <i>IDDFS</i>) ist ein Verfahren aus der <a href="Informatik" title="Informatik">Informatik</a> zum Suchen eines <a href="Knoten_(Graphentheorie)" title="Knoten (Graphentheorie)">Knotens</a> in einem <a href="Graph_(Graphentheorie)" title="Graph (Graphentheorie)">Graphen</a>. Der Algorithmus kombiniert die wünschenswerten Eigenschaften von <a href="Tiefensuche" title="Tiefensuche">Tiefensuche</a> (geringer Speicherverbrauch) und <a href="Breitensuche" title="Breitensuche">Breitensuche</a> (Optimalität).
</p><p>Die iterative Tiefensuche ist wie die normale Tiefensuche eine <a href="Suchalgorithmus#Heuristische_(Informierte)_Suchalgorithmen" class="mw-redirect" title="Suchalgorithmus">uninformierte Suche</a>. Sie funktioniert wie die <a href="Tiefensuche" title="Tiefensuche">Tiefensuche</a>, vermeidet jedoch durch Begrenzung der Suchtiefe deren Nachteile bezüglich Vollständigkeit. Bei der iterativen Tiefensuche wird iterativ eine <a href="Beschr%C3%A4nkte_Tiefensuche" title="Beschränkte Tiefensuche">beschränkte Tiefensuche</a> durchgeführt, und dabei das Level, bis zu welchem die Beschränkte Tiefensuche den <a href="Graph_(Graphentheorie)" title="Graph (Graphentheorie)">Graphen</a> erkundet, bei jeder <a href="Iteration" title="Iteration">Iteration</a> um eins erhöht. Im ersten Schritt werden also alle <a href="Knoten_(Graphentheorie)" title="Knoten (Graphentheorie)">Knoten</a>, zu denen ein <a href="Pfad_(Graphentheorie)" class="mw-redirect" title="Pfad (Graphentheorie)">Pfad</a> der Länge 0 führt, mittels Tiefensuche erkundet. Im nächsten Schritt werden dann alle Knoten, zu denen ein Pfad der Länge 1 führt, mittels Tiefensuche erkundet und so weiter. Hierdurch wird erreicht, dass Iterative Tiefensuche prinzipiell auf allen Graphen vollständig ist, da die Suche sich nun nicht mehr in einem endlos langen Pfad verlieren kann.
Damit stellt die iterative Tiefensuche eine Kombination der Tiefen- und der <a href="Breitensuche" title="Breitensuche">Breitensuche</a> dar. Sie hat einerseits den gleichen <a href="Platzkomplexit%C3%A4t" title="Platzkomplexität">Speicherplatzverbrauch</a> wie die normale Tiefensuche (im Arbeitsspeicher muss jeweils maximal ein kompletter Ast bis zur momentanen Iterationstiefe gespeichert werden), liefert aber bei monoton steigenden Pfadkosten, ebenso wie die Breitensuche, eine optimale Lösung. Da für jede neue Iteration auch der bereits durchlaufene <a href="Suchbaum" title="Suchbaum">Suchbaum</a> komplett neu aufgebaut werden muss, ist die <a href="Laufzeitkomplexit%C3%A4t" class="mw-redirect" title="Laufzeitkomplexität">Laufzeit</a> höher als bei normaler Tiefensuche. Da in einem Suchbaum aber jeweils der größte Teil der Knoten Blätter sind, ist dieser geringe Mehraufwand gegenüber den Vorteilen hinnehmbar.
</p>
<div class="mw-heading mw-heading2"><h2 id="Algorithmus_(informell)"><span id="Algorithmus_.28informell.29"></span>Algorithmus (informell)</h2></div>
<ol><li>Bestimme den Knoten, an dem die Suche beginnen soll</li>
<li>Rufe <a href="Beschr%C3%A4nkte_Tiefensuche" title="Beschränkte Tiefensuche">Beschränkte Tiefensuche</a> mit der aktuellen Suchtiefe auf</li>
<li>Erhöhe die Suchtiefe um 1 und gehe zu Schritt 2</li></ol>
<div class="mw-heading mw-heading2"><h2 id="Algorithmus_(formal)"><span id="Algorithmus_.28formal.29"></span>Algorithmus (formal)</h2></div>
<pre><b>Iterative Tiefensuche</b> (Knoten, Ziel)
{
IterationsTiefe := 0
while (IterationsTiefe < <i>unendlich</i>)
{
<b>Beschränkte_Tiefensuche</b> (Knoten, Ziel, IterationsTiefe);
IterationsTiefe := IterationsTiefe + 1;
}
}
</pre>
<div class="mw-heading mw-heading2"><h2 id="Algorithmusbeispiel:_Erzeugen_des_Tiefensuchwaldes_(iterativ)"><span id="Algorithmusbeispiel:_Erzeugen_des_Tiefensuchwaldes_.28iterativ.29"></span>Algorithmusbeispiel: Erzeugen des Tiefensuchwaldes (iterativ)</h2></div>
<p>Der folgende iterative Algorithmus erzeugt den Tiefensuchwald eines Graphen G mittels Setzen von Discovery- und Finishing-Times und Färben der Knoten. In Anlehnung an <a href="Thomas_H._Cormen" title="Thomas H. Cormen">Cormen</a>, <a href="Charles_Leiserson" class="mw-redirect" title="Charles Leiserson">Leiserson</a>, <a href="Ronald_L._Rivest" title="Ronald L. Rivest">Rivest</a>, <a href="Clifford_Stein" title="Clifford Stein">Stein</a>, Introduction to Algorithms, MIT Press, 2001, werden zunächst alle Knoten weiß gefärbt. Anschließend startet die Tiefensuche per Definition beim alphabetisch kleinsten Knoten und färbt diesen grau. Danach wird ein Stack verwendet, worin der bereits entdeckte Weg bis zu einem Knoten ohne weißen Nachbarn gespeichert wird. Alle Knoten im Stack sind grau.
Der Stack wird abgetragen, bis einer der gespeicherten Knoten noch einen weiteren weißen Nachbarn hat oder der Stack leer ist. Damit wird das der Rekursion eigene <a href="Backtracking" title="Backtracking">Backtracking</a> simuliert.
</p><p>Die vorgefertigte Methode nextw(u) liefert für einen Knoten u den (per Definition alphabetisch kleinsten) weißen Nachbarn. Existiert kein solcher, liefert sie NULL bzw. FALSE.
</p>
<div class="mw-highlight mw-highlight-lang-java mw-content-ltr mw-highlight-lines" dir="ltr"><pre><span></span><span class="linenos" data-line="1"></span><span class="k">for</span><span class="w"> </span><span class="n">each</span><span class="w"> </span><span class="n">v</span><span class="w"> </span><span class="n">of</span><span class="w"> </span><span class="n">G</span><span class="w"> </span><span class="p">{</span><span class="w"> </span><span class="c1">//Initialisierung:</span>
<span class="linenos" data-line="2"></span><span class="w"> </span><span class="n">col</span><span class="o">[</span><span class="n">v</span><span class="o">]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">w</span><span class="p">;</span><span class="w"> </span><span class="c1">//Alle Knoten weiß färben und</span>
<span class="linenos" data-line="3"></span><span class="w"> </span><span class="n">pi</span><span class="o">[</span><span class="n">v</span><span class="o">]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="kc">null</span><span class="p">;</span><span class="w"> </span><span class="c1">//Vorgänger auf null setzen</span>
<span class="linenos" data-line="4"></span><span class="p">}</span>
<span class="linenos" data-line="5"></span><span class="n">time</span><span class="o">=</span><span class="mi">0</span><span class="p">;</span><span class="w"> </span>
<span class="linenos" data-line="6"></span><span class="n">S</span><span class="o">=</span><span class="mi">0</span><span class="p">;</span><span class="w"> </span><span class="c1">//Stack S initialisieren</span>
<span class="linenos" data-line="7"></span>
<span class="linenos" data-line="8"></span><span class="k">for</span><span class="w"> </span><span class="n">each</span><span class="w"> </span><span class="n">u</span><span class="w"> </span><span class="n">of</span><span class="w"> </span><span class="n">G</span><span class="w"> </span><span class="p">{</span><span class="w"> </span><span class="c1">//für alle weißen Knoten u</span>
<span class="linenos" data-line="9"></span><span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="n">col</span><span class="o">[</span><span class="n">u</span><span class="o">]==</span><span class="n">w</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w"> </span>
<span class="linenos" data-line="10"></span><span class="w"> </span><span class="n">time</span><span class="o">++</span><span class="p">;</span><span class="w"> </span><span class="c1">//Zeitzähler erhöhen</span>
<span class="linenos" data-line="11"></span><span class="w"> </span><span class="n">col</span><span class="o">[</span><span class="n">u</span><span class="o">]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">g</span><span class="p">;</span><span class="w"> </span><span class="c1">//Aktuellen Knoten grau färben</span>
<span class="linenos" data-line="12"></span><span class="w"> </span><span class="n">d</span><span class="o">[</span><span class="n">u</span><span class="o">]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">time</span><span class="p">;</span><span class="w"> </span><span class="c1">//Entdeckzeit setzen</span>
<span class="linenos" data-line="13"></span><span class="w"> </span><span class="n">push</span><span class="p">(</span><span class="n">S</span><span class="p">,</span><span class="w"> </span><span class="n">u</span><span class="p">);</span><span class="w"> </span><span class="c1">//Aktuellen Knoten auf Stack</span>
<span class="linenos" data-line="14"></span><span class="w"> </span><span class="k">while</span><span class="w"> </span><span class="p">(</span><span class="n">S</span><span class="o">!=</span><span class="mi">0</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w"> </span><span class="c1">//Solange Stack belegt ist</span>
<span class="linenos" data-line="15"></span><span class="w"> </span><span class="n">time</span><span class="o">++</span><span class="p">;</span><span class="w"> </span><span class="c1">//Zeitzähler erhöhen</span>
<span class="linenos" data-line="16"></span><span class="w"> </span><span class="n">v</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">nextw</span><span class="p">(</span><span class="n">u</span><span class="p">);</span><span class="w"> </span>
<span class="linenos" data-line="17"></span><span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="n">v</span><span class="o">!=</span><span class="kc">null</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w"> </span><span class="c1">//wenn nächster weißer Nachbar</span>
<span class="linenos" data-line="18"></span><span class="w"> </span><span class="n">col</span><span class="o">[</span><span class="n">v</span><span class="o">]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">g</span><span class="p">;</span><span class="w"> </span><span class="c1">//v grau färben</span>
<span class="linenos" data-line="19"></span><span class="w"> </span><span class="n">d</span><span class="o">[</span><span class="n">v</span><span class="o">]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">time</span><span class="p">;</span><span class="w"> </span><span class="c1">//Entdeckzeit setzen</span>
<span class="linenos" data-line="20"></span><span class="w"> </span><span class="n">pi</span><span class="o">[</span><span class="n">v</span><span class="o">]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">u</span><span class="p">;</span><span class="w"> </span><span class="c1">//Vorgänger setzen</span>
<span class="linenos" data-line="21"></span><span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="n">nextw</span><span class="p">(</span><span class="n">v</span><span class="p">)</span><span class="o">!=</span><span class="kc">null</span><span class="p">)</span>
<span class="linenos" data-line="22"></span><span class="w"> </span><span class="n">push</span><span class="p">(</span><span class="n">S</span><span class="p">,</span><span class="w"> </span><span class="n">v</span><span class="p">);</span>
<span class="linenos" data-line="23"></span><span class="w"> </span><span class="n">u</span><span class="o">=</span><span class="n">v</span><span class="p">;</span><span class="w"> </span><span class="c1">//Aktueller Knoten ist v</span>
<span class="linenos" data-line="24"></span><span class="w"> </span><span class="p">}</span><span class="w"> </span><span class="k">else</span><span class="w"> </span><span class="p">{</span><span class="w"> </span><span class="c1">//wenn v NULL</span>
<span class="linenos" data-line="25"></span><span class="w"> </span><span class="n">col</span><span class="o">[</span><span class="n">u</span><span class="o">]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">s</span><span class="p">;</span><span class="w"> </span><span class="c1">//Aktuellen Knoten schwarz färben</span>
<span class="linenos" data-line="26"></span><span class="w"> </span><span class="n">f</span><span class="o">[</span><span class="n">u</span><span class="o">]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">time</span><span class="p">;</span><span class="w"> </span><span class="c1">//Finishing-Time setzen</span>
<span class="linenos" data-line="27"></span><span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="n">S</span><span class="o">!=</span><span class="mi">0</span><span class="p">)</span>
<span class="linenos" data-line="28"></span><span class="w"> </span><span class="n">u</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">pop</span><span class="p">(</span><span class="n">S</span><span class="p">);</span><span class="w"> </span><span class="c1">//neuer aktueller Knoten von Stack</span>
<span class="linenos" data-line="29"></span><span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="n">col</span><span class="o">[</span><span class="n">u</span><span class="o">]==</span><span class="n">g</span><span class="p">)</span>
<span class="linenos" data-line="30"></span><span class="w"> </span><span class="n">push</span><span class="p">(</span><span class="n">S</span><span class="p">,</span><span class="n">u</span><span class="p">);</span><span class="w"> </span><span class="c1">//Solange Knoten noch nicht Schwarz, wieder auf den Stack</span>
<span class="linenos" data-line="31"></span><span class="w"> </span><span class="p">}</span>
<span class="linenos" data-line="32"></span><span class="w"> </span><span class="p">}</span>
<span class="linenos" data-line="33"></span><span class="w"> </span><span class="p">}</span>
<span class="linenos" data-line="34"></span><span class="w"> </span><span class="p">}</span>
</pre></div>
<div class="mw-highlight mw-highlight-lang-java mw-content-ltr mw-highlight-lines" dir="ltr"><pre><span></span><span class="linenos" data-line="1"></span><span class="n">nextw</span><span class="p">(</span><span class="n">u</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<span class="linenos" data-line="2"></span><span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="n">each</span><span class="w"> </span><span class="n">node</span><span class="w"> </span><span class="n">of</span><span class="w"> </span><span class="n">adj</span><span class="o">[</span><span class="n">u</span><span class="o">]</span><span class="w"> </span><span class="p">{</span>
<span class="linenos" data-line="3"></span><span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="n">col</span><span class="o">[</span><span class="n">node</span><span class="o">]==</span><span class="n">w</span>
<span class="linenos" data-line="4"></span><span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">node</span><span class="p">;</span>
<span class="linenos" data-line="5"></span><span class="w"> </span><span class="p">}</span>
<span class="linenos" data-line="6"></span><span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="kc">null</span><span class="p">;</span>
<span class="linenos" data-line="7"></span><span class="p">}</span>
</pre></div>
<div class="mw-heading mw-heading2"><h2 id="Eigenschaften">Eigenschaften</h2></div>
<div class="mw-heading mw-heading3"><h3 id="Speicherplatzverbrauch">Speicherplatzverbrauch</h3></div>
<p>Da intern auf Tiefensuche zurückgegriffen wird, ist der Speicherplatzbedarf ähnlich dem der normalen Tiefensuche.
</p>
<div class="mw-heading mw-heading3"><h3 id="Laufzeit">Laufzeit</h3></div>
<p>Da im schlimmsten Fall alle möglichen Pfade zu allen möglichen Knoten betrachtet werden müssen, beträgt die Laufzeit von Iterativer Tiefensuche <span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle {\mathcal {O}}(\vert V\vert +\vert E\vert )}">
<semantics>
<mrow class="MJX-TeXAtom-ORD">
<mstyle displaystyle="true" scriptlevel="0">
<mrow class="MJX-TeXAtom-ORD">
<mrow class="MJX-TeXAtom-ORD">
<mi class="MJX-tex-caligraphic" mathvariant="script">O</mi>
</mrow>
</mrow>
<mo stretchy="false">(</mo>
<mo fence="false" stretchy="false">|</mo>
<mi>V</mi>
<mo fence="false" stretchy="false">|</mo>
<mo>+</mo>
<mo fence="false" stretchy="false">|</mo>
<mi>E</mi>
<mo fence="false" stretchy="false">|</mo>
<mo stretchy="false">)</mo>
</mstyle>
</mrow>
<annotation encoding="application/x-tex">{\displaystyle {\mathcal {O}}(\vert V\vert +\vert E\vert )}</annotation>
</semantics>
</math></span><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/fafd762d516b0f9ebcb1fc41524000c2c610d4c3.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.838ex; width:12.65ex; height:2.843ex;" alt="{\displaystyle {\mathcal {O}}(\vert V\vert +\vert E\vert )}" loading="lazy"></span>, wobei <span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle \vert V\vert }">
<semantics>
<mrow class="MJX-TeXAtom-ORD">
<mstyle displaystyle="true" scriptlevel="0">
<mo fence="false" stretchy="false">|</mo>
<mi>V</mi>
<mo fence="false" stretchy="false">|</mo>
</mstyle>
</mrow>
<annotation encoding="application/x-tex">{\displaystyle \vert V\vert }</annotation>
</semantics>
</math></span><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/a1b87251a78485894ca9c544f7582de9b5d4aedb.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.838ex; width:3.081ex; height:2.843ex;" alt="{\displaystyle \vert V\vert }" loading="lazy"></span> für die Anzahl der Knoten und <span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle \vert E\vert }">
<semantics>
<mrow class="MJX-TeXAtom-ORD">
<mstyle displaystyle="true" scriptlevel="0">
<mo fence="false" stretchy="false">|</mo>
<mi>E</mi>
<mo fence="false" stretchy="false">|</mo>
</mstyle>
</mrow>
<annotation encoding="application/x-tex">{\displaystyle \vert E\vert }</annotation>
</semantics>
</math></span><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/e77aaf6d84a9a506ae76b7bd1418a7cf6ae68365.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.838ex; width:3.069ex; height:2.843ex;" alt="{\displaystyle \vert E\vert }" loading="lazy"></span> für die Anzahl der <a href="Kante_(Graphentheorie)" title="Kante (Graphentheorie)">Kanten</a> im Graph steht.
</p>
<div class="mw-heading mw-heading3"><h3 id="Vollständigkeit"><span id="Vollst.C3.A4ndigkeit"></span>Vollständigkeit</h3></div>
<p>Da sich Iterative Tiefensuche weder in unendlich langen Pfaden noch in <a href="Zyklus_(Graphentheorie)" title="Zyklus (Graphentheorie)">Zyklen</a> verlieren kann, ist der Algorithmus vollständig.
</p>
<div class="mw-heading mw-heading3"><h3 id="Optimalität"><span id="Optimalit.C3.A4t"></span>Optimalität</h3></div>
<p>Iterative Tiefensuche ist optimal, falls alle Pfadkosten äquivalent sind, da Tiefensuche in diesem Fall den kürzesten Pfad zu einem Ziel findet. Sind die Pfadkosten jedoch nicht äquivalent, so kann es wie bei der Breitensuche dazu kommen, dass ein suboptimaler Pfad gewählt wird.
</p>
<div class="mw-heading mw-heading2"><h2 id="Literatur">Literatur</h2></div>
<ul><li>Stuart Russell, <a href="Peter_Norvig" title="Peter Norvig">Peter Norvig</a>: <i><a rel="nofollow" class="external text" href="http://aima.cs.berkeley.edu/">Artificial Intelligence: A Modern Approach</a></i>, 2. Auflage, 2002, Prentice Hall.</li>
<li>Thomas H. Cormen, <a href="Charles_Leiserson" class="mw-redirect" title="Charles Leiserson">Charles Leiserson</a>, <a href="Ronald_L._Rivest" title="Ronald L. Rivest">Ronald L. Rivest</a>, Clifford Stein: <i>Introduction to Algorithms</i>, MIT Press, 2nd edition 2001, ISBN 0-262-53196-8</li></ul></div><!--htdig_noindex--><div><div class="zim-footer">
Dieser Artikel wurde von <a class="external text" title="Zuletzt bearbeitet am 2025-04-30" href="https://de.wikipedia.org/wiki/?title=Iterative_Tiefensuche&oldid=255586558">Wikipedia</a> herausgegeben. Der Text ist unter <a class="external text" href="https://creativecommons.org/licenses/by-sa/4.0/deed.de">Creative Commons Attribution-Share Alike 4.0</a> verfügbar, sofern nicht anders angegeben. Für die Mediendateien können zusätzliche Bedingungen gelten.
</div>
</div><!--/htdig_noindex--></div>
</div>
</main>
</div>
</div>
</div>
<script src="./_webp_/webpHandler.js"></script>
</body></html>